package com.wss.common.base;

import com.orhanobut.logger.*;
import com.wss.common.bean.User;
import com.wss.common.constants.Dic;
import com.wss.common.manage.AbilityManage;
import com.wss.common.utils.CacheUtils;
import com.wss.common.utils.ToastUtils;
import com.wss.common.utils.ValidUtils;
import com.wss.common.utils.toast.ToastInterceptor;
import com.wss.common.utils.toast.style.ToastBlackStyle;
import com.zhouyou.http.EasyHttp;
import io.reactivex.rxjava3.disposables.Disposable;
import ohos.aafwk.ability.AbilityPackage;
import ohos.agp.window.dialog.ToastDialog;
import ohos.app.Context;
import ohos.os.ProcessManager;

import java.util.HashMap;
import java.util.Map;

//TODO BaseApplication部分内容未移植
public class BaseApplication extends AbilityPackage {

    /**
     * 全局上下文
     */
    private static BaseApplication application;

    /**
     * Ability管理器
     */
    private AbilityManage abilityManage;

    /**
     * 保存所有网络请求
     */
    private Map<String, Disposable> netDisposable;

    /**
     * 登录用户
     */
    private User user;

    @Override

    public void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        application = this;
    }

    @Override
    public void onInitialize() {
        super.onInitialize();
        abilityManage = new AbilityManage();
        //初始化日志框架
        initLogger();
        //初始化Toast
        initToast();
        //初始化网络
        initHttp();
    }

    /**
     * 初始化日志打印框架
     */
    private void initLogger() {
        FormatStrategy formatStrategy = PrettyFormatStrategy.newBuilder()
                //（可选）是否显示线程信息。 默认值为true
                .showThreadInfo(false)
                //（可选）要显示的方法行数。 默认2
                .methodCount(0)
                //（可选）设置调用堆栈的函数偏移值，0的话则从打印该Log的函数开始输出堆栈信息，默认是0
                .methodOffset(7)
                //（可选）更改要打印的日志策略。 默认LogCat
                .logStrategy(new LogcatLogStrategy())
                //（可选）每个日志的全局标记。 默认PRETTY_LOGGER
                .tag("APP_LOG")
                .build();

        Logger.addLogAdapter(new HarmonyLogAdapter(formatStrategy) {
            @Override
            public boolean isLoggable(int priority, String tag) {
                //非DEBUG模式下不打印LOG
                return BuildConfig.DEBUG;
            }
        });
    }

    /**
     * B
     * 初始化Toast
     */
    private void initToast() {

        ToastUtils.setToastInterceptor(new ToastInterceptor() {
            @Override
            public boolean intercept(ToastDialog toast, String text) {
                boolean intercept = super.intercept(toast, text);
                if (intercept) {
                    Logger.e("空 Toast");
                } else {
                    Logger.d(text.toString());
                }
                return intercept;
            }
        });
        // 初始化吐司工具类
        ToastUtils.init(this, new ToastBlackStyle(this));
    }

    /**
     * 初始化网络
     */
    private void initHttp() {
        EasyHttp.init(this);

    }

    /**
     * 获取全局唯一上下文
     *
     * @return BaseApplication
     */
    public static BaseApplication i() {
        return application;
    }

    /**
     * 退出应用
     */
    public void exitApp() {
        abilityManage.finishAll();
        ProcessManager.kill(ProcessManager.getPid());
        System.exit(0);
    }

    /**
     * 获取Ability管理器
     *
     * @return AbilityManage
     */
    public AbilityManage getAbilityManage() {
        if (abilityManage == null) {
            abilityManage = new AbilityManage();
        }
        return abilityManage;
    }

    /**
     * 获取存放的请求对象
     *
     * @return Map
     */
    public Map<String, Disposable> getNetDisposables() {
        if (netDisposable == null) {
            return new HashMap<>(16);
        }
        return netDisposable;
    }

    /**
     * 退出登录清除换群
     */
    public void loginOutClean() {

    }

    /**
     * 添加请求对象
     *
     * @param requestId  请求ID
     * @param disposable 对象
     */
    public void addNetDisposable(String requestId, Disposable disposable) {
        if (netDisposable == null) {
            netDisposable = new HashMap<>(16);
        }
        netDisposable.put(requestId, disposable);
    }

    /**
     * 根据请求ID移除该对象
     *
     * @param requestId 请求ID
     */
    public void removeNetDisposable(String requestId) {
        netDisposable.remove(requestId);
    }

    /**
     * 保存用户信息
     *
     * @param user 登录用户
     */
    public void setUser(User user) {
        CacheUtils.get(this).put(Dic.LOGIN_USER_INFO, user);
        this.user = user;
    }

    /**
     * 获取用户信息
     *
     * @return User
     */
    public User getUser() {

        if (!ValidUtils.isValid(user) || !ValidUtils.isValid(user.getId())) {
            //如果保存的user为空，则去本地缓存中取
            user = (User) CacheUtils.get(this).getAsObject(Dic.LOGIN_USER_INFO);
        }
        if (!ValidUtils.isValid(user)) {
            //防止异常情况下getUser对象为null问题
            user = new User();
        }
        return user;
    }

    /**
     * 是否登录
     *
     * @return boolean
     */
    public boolean isLogged() {
        User user = getUser();
        return ValidUtils.isValid(user) && ValidUtils.isValid(user.getId());
    }

    public String getDeviceId() {
        return "";
    }

    public String getLoginToken() {
        return "";
    }
}
